//导入包的方法

/*1.
import java.util.Arrays;
import java.util.Date;//这个就是一个包*/
//Date和Arrays都是在util这个包下面的，我们就可以写成下面这样
//2.
import jdk.internal.org.objectweb.asm.tree.MultiANewArrayInsnNode;

import java.util.*;
import java.sql.*;
//这里的.*相当于一个通配符 可以充当任何类
//但他不是导入util下的所有类，我们用到哪个类他就会帮我们导入哪个类
//3.
import static java.lang.Math.*;//静态导入包

//类的定义格式 class 类名{成员变量；成员方法}
class Student {//此时这个类的前面什么都没写就是default（默认访问权限）
    private String name = "悟空";//这叫就地初始化
    private int age;//普通变量  普通变量是每个对象都有一份
    public static int classRoom = 301;//static修饰了就是静态成员变量，静态成员变量是所有对象共用一份

    public Student(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("调用带两个参数的构造方法");
    }
    public Student() {
        //this.name = "牛孟俊";
        //this.age = 21;
        this("牛孟俊",18);//这就可以间接调用带两个参数的构造方法
        //必须是构造方法中的第一句
        System.out.println("调用不带参数的构造方法");
    }

    public void doClass() {
        System.out.println(this.name+"上课");//this 表示当前对象的引用
    }
    public void print() {
        System.out.println("姓名： " + this.name + " 年龄："+ this.age );
    }

    public static void func1() {

    }
    //类方法（静态成员方法）
    public static void funcStatic() {
       // print();//类方法的内部是不能调用普通方法的，因为静态方法不依赖对象，但普通方法依赖对象

        func1();
        //类方法是可以调用当前类的类方法的
        System.out.println("funstatic()..........");
    }
    //下面就是类的封装，这样我们可以不展示我们类的细节，为用户提供一个公开的接口
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class Test {//这个类是public修饰的（公共权限），谁都可以看到

    public static void main(String[] args) {
        Student.funcStatic();




       /* Student student = new Student();
        Student student1 = student;//这个的意思是student1指向的是student所指向的对象，并不是引用指向引用的意思
        //引用只能指向引用*/

        /*Student student = null;
        System.out.println(student.classRoom);//这里访问的是classRoom是静态变量，静态变量是不属于对象的，所以我们访问的时候不会出现异常*/


    }

    public static void main6(String[] args) {

        Student student1 = new Student("zhangsan",18);
        Student student2 = new Student("lisi",8);
        Student student3 = new Student("wanghu",28);
        /*//因为这三个同学都是在同一个教室上课，所以我们就用static来修饰classRoom，三个学生都可以公用一个类了
        //所以我们就可以不用在每个对象中去指定classRoom了
        System.out.println("教室是： "+ student1.classRoom);
        System.out.println("教室是： "+ student2.classRoom);
        System.out.println("教室是： "+ student3.classRoom);
        //使用的是对象访问，因为此时classRoom不是属于对象的，所以我们对象.的时候就看不到classRoom*/

        //建议通过类名.的方式进行访问
        System.out.println("教室是： "+Student.classRoom);
        //类的静态变量通过类名访问，说明这个静态成员变量不属于对象，所以我们创不创建对象是没有关系的
    }





    public static void main5(String[] args) {
        Student student = new Student();
        //student.name = "张三";
        student.setName("zhangsan");
        //student.age = 10;
        student.setAge(10);
        student.print();
    }
    public static void main4(String[] args) {
        double d = 19.9;
        double f = 90.9;
        double result = Math.sqrt(Math.pow(d,2) + Math.pow(f,2));
        //sqor是开平方
        //pow是d的2的次方

        //我们已经导入了包之后我们就可以写成
        double result2 = sqrt(pow(d,2) + pow(f,2));
        System.out.println(result);
    }

    public static void main3(String[] args) {
        //如果我们不导入包也可以
        //那我们就要这样写
        //java.util.Arrays.sort();//就要这样来写
        //我们需要用Arrays里面的东西的时候我们就需要导入Arrays的包
        //类似于c语言中引用的头文件
        java.util.Date date = new java.util.Date();//这样也可以帮我们导入Date这个包

        //为了使用简洁
        //我们可以在上面先导入包
        //Date date1 = new Date();//此时编译器就不清楚你所引用的类是ntil下的还是sql下的Date类
        //但是这种并不是光由.*引起的，也可能已经导入了sql和util这两个包，所以我们还是需要进行指定

        //所以我们就需要指定的去写（需要使用完整的类名）
        java.util.Date date2 = new java.util.Date();
        int[] array = {1,2,3,4,5};
        Arrays.sort(array);
    }
    //上面已经有一个学会类了，现在我们要来产生这个一个学生对象
    public static void main2(String[] args) {
        Student student = new Student();
        student.print();
    }
    public static void main1(String[] args) {
        //创建一个学生对象
        //一个对象产生至少需要进行两步：public Student() {
        //        System.out.println("调用不带参数的构造方法");
        //    }
        //1.为对象分配内存
        //2.调用（合适）的构造方法（也就说明可以有多个构造方法）
        Student student = new Student();
        //通过对象的引用来进行赋值
        //student.name = "张三";
        //student.age = 10;
        //调用方法
        // 调用类的doClass方法
        Student student1 = new Student("李四",18);
        student1.doClass();
        //在Java当中当你写了一个构造方法之后，编译器就不会帮你生成构造方法了
        //一个没写的时候，编译器才会帮你生成构造方法
    }
}
